package yi.wuhenbot.Service;

import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import yi.wuhenbot.Utils.KimiUtil;
import yi.wuhenbot.dao.KimiUserMapper;

import java.time.LocalDateTime;

/**
 * @author wuhen
 */
@Service("kimiUserService")
public class KimiUserService {

    @Autowired
    private OrgUserService orgUserService;
    @Autowired
    private KimiUserMapper kimiUserMapper;
    @Autowired
    private GroupMessageService groupMessageService;
    /**
     * 开启对话 用户指令 kimi（数据库查询）
     * @param groupid 用户id
     */
    public String startConversation(String typeId,String type,String groupid) {
        //System.out.println("groupid: "+groupid+"user"+groupid);
        // 打印全部方法参数
        //System.out.println("typeId: "+typeId+"type: "+type+"groupid: "+groupid);
        // 检查orguser是否存在
        if (!orgUserService.isUserExist(groupid)) {
            // 不存在则新增用户
            orgUserService.userEnroll(groupid,"GROUP",groupid);
        }
        // 检查用户是否存在
        if (!kimiUserMapper.isKimiUserExist(groupid)) {
            // 不存在则新增用户
            insertKimiUser(typeId,type,groupid);
        }
        // 检测用户是否已开启对话
        if (orgUserService.isUserOnline(groupid,"GROUP",groupid)) {
            return "用户已开启对话";
        }
        // 更新用户连续对话状态为已开启
        orgUserService.updateonline_status(groupid,"GROUP",groupid, 1);
        return "kimi对话已开启，开始聊天吧！";
    }
    /**
     * 设置群提示词
     * @param groupid 群id
     * @param messages 对话内容
     */
    public void setGroupPrompt(String userOpenid, String groupid, String messages){
        // 检查群是否存在
        if (!groupMessageService.isGroupExist(groupid)) {
            // 不存在则新增群
            groupMessageService.insertGroupMessage(groupid);

        }
        String newAssistantContent = "{\"role\": \"system\", \"content\": \"" + messages + "\"}";
        // 存在则更新群消息
        groupMessageService.updateGroupMessageByGroupid(groupid,newAssistantContent);
    }
    /**
     * 设置本群提示词
     * @param typeId 群id
     * @param messages 对话内容
     */
    public String setGroupPrompt(String typeId,String type,String userOpenid, String messages){
        // 检查用户是否为管理员
        if (!orgUserService.isAdmin(typeId,type,userOpenid)){
            return "您不是管理员，无法设置群提示词";
        }
        if (!type.equals("GROUP") && !type.equals("CHANNEL")){
            return "请勿在非群聊中使用该指令";
        }
        // 检查群是否存在
        if (!groupMessageService.isGroupExist(typeId)) {
            // 不存在则新增群
            groupMessageService.insertGroupMessage(typeId);

        }
        String newAssistantContent = "{\"role\": \"system\", \"content\": \"" + messages + "\"}";
        // 存在则更新群消息
        groupMessageService.updateGroupMessageByGroupid(typeId,newAssistantContent);
        return "群提示词已设置为：\n"+messages;
    }
    /**
     * 查看本群提示词
     * @param typeId 群id
     * @return 提示词
     */
     public String getGroupPrompt(String typeId,String type){
         if (!type.equals("GROUP") && !type.equals("CHANNEL")){
            return "请勿在非群聊中使用该指令";
        }
        // 检查群是否存在
        if (!groupMessageService.isGroupExist(typeId)) {
            // 不存在则返回空
            return "本群未设置群提示词";
        }
        // 存在则查询群消息提取content
        String groupMessage = groupMessageService.selectGroupMessageByGroupid(typeId);
        // 提取content内容
        String prompt = groupMessage.split("\"content\": \"")[1].split("\"")[0];
        prompt = "本群提示词为：\n"+prompt;
        return prompt;
    }



    /**
     * 对话-群聊
     * @param user_id 用户id
     * @param messages 对话内容
     * @return 结果
     */
    public String conversationGroup(String typeId,String type,String user_id, String groupid, String messages, String content) {
        System.out.println("开始处理群聊对话");
        // 打印全部方法参数
        //System.out.println("处理中参数：typeId: "+typeId+"，type: "+type+"，user_id: "+user_id+"，groupid: "+groupid+"，messages: "+messages+"，content: "+content);
        // 检查用户是否存在
        if (!kimiUserMapper.isKimiUserExist(user_id)) {
            System.out.println("用户" + user_id + "不存在");
            // 不存在则新增用户
            insertKimiUser(typeId,type,user_id);
        }
        // 拼接新的用户内容
        String newContent = "{\"role\": \"user\", \"content\": \""+content+"\"}";
        // 检查当前用户是否有messages，如果没有则用传递传递的参数，如果有，则用数据库查询的
        if(kimiUserMapper.isKimiUserMessagesExist(user_id)){
            // 存在则用数据库查询的
            messages = kimiUserMapper.selectKimiUserMessages(typeId,type,user_id);
        }else {
            // 不存在则用传递的参数,并把""转换为转义符号
            // 把""转换为转义符号
            messages = messages.replaceAll("\"", "\\\"");
        }
        // messages处理为数组
        String returnForMessages = "\"messages\":["+messages+","+newContent+"]";
        // 调用kimi工具类
        JSONObject result = KimiUtil.callKimiApi(user_id, returnForMessages,newContent);
        // 拼接新的assistant内容
        String newAssistantContent = "{\"role\": \"assistant\", \"content\": \"" + result.getString("content") + "\"}";
        // messages拼接更新到数据库
        returnForMessages = messages + ","+newContent+","+newAssistantContent;
        // 将文字中的换行符替换为空格
        returnForMessages = returnForMessages.replaceAll("\n", " ");
        System.out.println("入库数据："+returnForMessages);
        // 更新用户messages用于后续查询进行多轮对话
        kimiUserMapper.updateKimiUserMessages(user_id, returnForMessages, LocalDateTime.now());
        return result.getString("content");
    }
    /**
     * 对话-私聊
     * @param content 对话内容
     * @return 结果
     */
    public String conversationPrivate(String typeId,String type,String user_id,String content) {
        System.out.println("开始处理私聊对话");
        // 打印全部方法参数
        //System.out.println("处理中参数：typeId: "+typeId+"，type: "+type+"，user_id: "+user_id+"，content: "+content);

        // 检查用户是否存在
        if (!kimiUserMapper.isKimiUserExist(user_id)) {
            // 不存在则新增用户
            insertKimiUser(typeId,type,user_id);
        }
        // 从数据库查询messages
        String messages = kimiUserMapper.selectKimiUserMessages(typeId,type,user_id);

        // 拼接新的用户内容
        String newContent = "{\"role\": \"user\", \"content\": \""+content+"\"}";
        // messages处理为数组
        String returnForMessages = "\"messages\":["+messages+","+newContent+"]";
        // 调用kimi工具类
        JSONObject result = KimiUtil.callKimiApi(user_id, returnForMessages,newContent);
        // 拼接新的assistant内容
        String newAssistantContent = "{\"role\": \"assistant\", \"content\": \"" + result.getString("content") + "\"}";
        // messages拼接更新到数据库
        returnForMessages = messages + ","+newContent+","+newAssistantContent;
        // 将文字中的换行符替换为空格
        returnForMessages = returnForMessages.replaceAll("\n", " ");
        System.out.println("入库数据："+returnForMessages);
        // 更新用户messages用于后续查询进行多轮对话
        kimiUserMapper.updateKimiUserMessages(user_id, returnForMessages, LocalDateTime.now());
        return result.getString("content");
    }
    /**
     * 新增kimi用户
     * @param user_id 用户id
     * @return 结果
     */
    public int insertKimiUser(String typeId,String type,String user_id) {
        return kimiUserMapper.insertKimiUser(user_id);
    }
    /**
     * 根据用户id查询kimi用户messages
     * @param user_id 用户id
     * @return kimi用户messages
     */
    public String selectKimiUserMessages(String typeId,String type,String user_id) {
        // 检查用户是否存在
        if (kimiUserMapper.selectKimiUserMessages(typeId,type,user_id) == null) {
            // 不存在则新增用户
            insertKimiUser(typeId,type,user_id);
        }
        return kimiUserMapper.selectKimiUserMessages(typeId,type,user_id);
    }
    /**
     * 更新kimi用户messages
     * @param user_id 用户id
     * @param messages 对话内容
     * @return 结果
     */
    public int updateKimiUserMessages(String typeId,String type,String user_id, String messages) {
        // 检查用户是否存在
        if (!kimiUserMapper.isKimiUserExist(user_id)) {
            // 不存在则新增用户
            insertKimiUser(typeId,type,user_id);
        }
        return kimiUserMapper.updateKimiUserMessages(user_id, messages, LocalDateTime.now());
    }
    /**
     * 清空用户数据
     * @param user_id 用户id
     * @return 结果
     */
    public int clearKimiUserMessages(String typeId,String type,String user_id) {
        // 检查用户是否存在
        if (kimiUserMapper.selectKimiUserMessages(typeId,type,user_id) == null) {
            // 不存在则新增用户
            insertKimiUser(typeId,type,user_id);
        }
        return kimiUserMapper.clearKimiUserMessages(user_id);
    }
    /**
     * 检查用户是否有messages
     * @param user_id 用户id
     * @return true存在 false不存在
     */
    public boolean isKimiUserMessagesExist(String user_id) {
        return kimiUserMapper.isKimiUserMessagesExist(user_id);
    }
    /**
     * 获取用户total_tokens
     * @param user_id 用户id
     * @return total_tokens
     */
    public int selectKimiUserTotalTokens(String user_id) {
        return kimiUserMapper.selectKimiUserTotalTokens(user_id);
    }
    /**
     * 更新用户total_tokens
     * @param user_id 用户id
     * @param total_tokens total_tokens
     * @return 结果
     */
    public int updateKimiUserTotalTokens(String user_id, int total_tokens) {
        return kimiUserMapper.updateKimiUserTotalTokens(user_id, total_tokens);
    }

}
